package com.foreveross.proxyip.util;

import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.PBEKeySpec;
import javax.crypto.spec.PBEParameterSpec;
/**
 * 字符串加密解密类
 * @author lyq
 *
 */
public class SecretUtil {
	
	/**
	 * 得到对称加密字符串
	 * @param password 未加密密码
	 * @return
	 * @throws Exception
	 */
	public static String secretEncrypt(String password) throws Exception { 
	    //实例化工具 
	    Cipher cipher=Cipher.getInstance("PBEWithMD5AndDES"); 
	     
	    //使用该工具将基于密码的形式生成Key 
	    SecretKey key=SecretKeyFactory.getInstance("PBEWithMD5AndDES").generateSecret(new PBEKeySpec(Config.kouling.toCharArray())); 
	    PBEParameterSpec parameterspec=new PBEParameterSpec(new byte[]{1,2,3,4,5,6,7,8},1000); 
	     
	    //初始化加密操作，同时传递加密的算法 
	    cipher.init(Cipher.ENCRYPT_MODE,key,parameterspec); 
	     
	     //将要加密的数据传递进去，返回加密后的数据 
	    byte [] results = cipher.doFinal(password.getBytes("UTF-8")); 
	    String keyword = new String(byteArr2HexStr(results));
	   return keyword;
	} 
	 
	/**
	 * 得到密码
	 * @param keyword 对称加密密码
	 * @return 
	 * @throws Exception
	 */
	public static String secretDecrypt(String keyword) throws Exception{ 
	    Cipher cipher2=Cipher.getInstance("PBEWithMD5AndDES"); 
	    SecretKey key2=SecretKeyFactory.getInstance("PBEWithMD5AndDES").generateSecret(new PBEKeySpec(Config.kouling.toCharArray())); 
	    PBEParameterSpec parameterspec=new PBEParameterSpec(new byte[]{1,2,3,4,5,6,7,8},1000); 
	    cipher2.init(Cipher.DECRYPT_MODE,key2,parameterspec); 
	    byte [] result=cipher2.doFinal(hexStr2ByteArr(keyword)); 
	    return new String(result);
	} 
	
	
	  /**  
	   * 将byte数组转换为表示16进制值的字符串， 如：byte[]{8,18}转换为：0813， 和public static byte[]  
	   * hexStr2ByteArr(String strIn) 互为可逆的转换过程  
	   *   
	   * @param arrB  
	   *            需要转换的byte数组  
	   * @return 转换后的字符串  
	   * @throws Exception  
	   *             本方法不处理任何异常，所有异常全部抛出  
	   */
	private static String byteArr2HexStr(byte[] arrB) throws Exception {
	    int iLen = arrB.length;
	    // 每个byte用两个字符才能表示，所以字符串的长度是数组长度的两倍   
	    StringBuffer sb = new StringBuffer(iLen * 2);
	    for (int i = 0; i < iLen; i++) {
	      int intTmp = arrB[i];
	      // 把负数转换为正数   
	      while (intTmp < 0) {
	        intTmp = intTmp + 256;
	      }
	      // 小于0F的数需要在前面补0   
	      if (intTmp < 16) {
	        sb.append("0");
	      }
	      sb.append(Integer.toString(intTmp, 16));
	    }
	    return sb.toString();
	  }

	  /**  
	   * 将表示16进制值的字符串转换为byte数组， 和public static String byteArr2HexStr(byte[] arrB)  
	   * 互为可逆的转换过程  
	   *   
	   * @param strIn  
	   *            需要转换的字符串  
	   * @return 转换后的byte数组  
	   * @throws Exception  
	   *             本方法不处理任何异常，所有异常全部抛出  
	   */
	  private static byte[] hexStr2ByteArr(String strIn) throws Exception {
	    byte[] arrB = strIn.getBytes();
	    int iLen = arrB.length;
	    if(iLen%16!=0){//错误
	    	return null;
	    }
	    // 两个字符表示一个字节，所以字节数组长度是字符串长度除以2   
	    byte[] arrOut = new byte[iLen / 2];
	    for (int i = 0; i < iLen; i = i + 2) {
	      String strTmp = new String(arrB, i, 2);
	      arrOut[i / 2] = (byte) Integer.parseInt(strTmp, 16);
	    }
	    return arrOut;
	  }

	  public static void main(String[] args) throws Exception {
		 System.out.println(System.currentTimeMillis());
	 }
}
